home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Programming / C / hf^k-3.dms / in.adf / C-Incl.Lha / iostream.h < prev    next >
Encoding:
C/C++ Source or Header  |  1996-08-07  |  11.6 KB  |  514 lines
  1. #ifndef _INCLUDE_IOSTREAM_H
  2. #define _INCLUDE_IOSTREAM_H
  3.  
  4. /*
  5. **  $VER: iostream.h 1.1 (6.8.96)
  6. **  StormC Release 1.1
  7. **
  8. **  '(C) Copyright 1995 Haage & Partner Computer GmbH'
  9. **     All Rights Reserved
  10. */
  11.  
  12. #ifndef __cplusplus
  13. #error <iostream.h> must be compiled in C++ mode.
  14. #pragma +
  15. #endif
  16.  
  17. #ifndef _INCLUDE_STDDEF_H
  18. #include <stddef.h>
  19. #endif
  20.  
  21. #ifndef _INCLUDE_STRING_H
  22. #include <string.h>
  23. #endif
  24.  
  25. #ifndef _INCLUDE_STDIO_H
  26. #include <stdio.h>
  27. #endif
  28.  
  29. class streambuf;
  30. class ostream;
  31. class istream;
  32.  
  33. typedef long streamoff;
  34.  
  35. class streampos {
  36. public:
  37.     streampos() { offset = 0; };
  38.     streampos(long o) { offset = o; };
  39.     operator long() { return offset; };
  40.     fpos_t* fpos() { return (fpos_t *) &offset; };
  41.     long offset;
  42. };
  43.  
  44. class ios {
  45. public:
  46.     enum io_state { 
  47.         goodbit  = 0x00,
  48.         eofbit   = 0x01,
  49.         failbit  = 0x02,
  50.         badbit   = 0x04,
  51.         hardfail = 0x80
  52.     };
  53.     enum open_mode { 
  54.         in        = 0x01,
  55.         out       = 0x02,
  56.         ate       = 0x04,
  57.         app       = 0x08,
  58.         trunc     = 0x10,
  59.         nocreate  = 0x20,
  60.         noreplace = 0x40,
  61.         binary    = 0x80
  62.     };
  63.     enum seek_dir  { 
  64.         beg = -1,
  65.         cur = 0, 
  66.         end = 1
  67.     };
  68.     enum {
  69.         skipws     = 0x00000001,
  70.         left       = 0x00000002,
  71.         right      = 0x00000004,
  72.         internal   = 0x00000008,
  73.         dec        = 0x00000010,
  74.         oct        = 0x00000020,
  75.         hex        = 0x00000040,
  76.         showbase   = 0x00000080,
  77.         showpoint  = 0x00000100,
  78.         uppercase  = 0x00000200,
  79.         showpos    = 0x00000400,
  80.         scientific = 0x00000800,
  81.         fixed      = 0x00001000,
  82.         unitbuf    = 0x00002000,
  83.         stdio      = 0x00004000,
  84.         firstfreebit = 0x00008000 
  85.     };
  86.  
  87.     ios(streambuf *b) { init(b); };
  88.     virtual ~ios() { };
  89.     unsigned long flags() { return aFlags; };
  90.     unsigned long flags(unsigned long f) 
  91.     { 
  92.         unsigned long r = aFlags; 
  93.         aFlags = f; 
  94.         return r; 
  95.     };
  96.     unsigned long setf(unsigned long f)
  97.     {
  98.         unsigned long r = aFlags & f;
  99.         aFlags |= f;
  100.         return r;
  101.     };
  102.     unsigned long unsetf(unsigned long f)
  103.     {
  104.         unsigned long r = aFlags & f;
  105.         aFlags &= ~f;
  106.         return r;
  107.     };
  108.     unsigned long setf(unsigned long f, unsigned long m)
  109.     {
  110.         unsigned long r = aFlags & m;
  111.         aFlags &= ~m;
  112.         aFlags |= (f & m);
  113.         return r;
  114.     };
  115.     int width() { return aWidth; };
  116.     int width(int w)
  117.     {
  118.         int r = aWidth;
  119.         aWidth = w;
  120.         return r;
  121.     };
  122.     ostream *tie() { return aTie; };
  123.     ostream *tie(ostream *o)
  124.     {
  125.         ostream *r = aTie;
  126.         aTie = o;
  127.         return r;
  128.     };
  129.     char fill() { return aFill; };
  130.     char fill(char f)
  131.     {
  132.         char r = aFill;
  133.         aFill = f;
  134.         return r;
  135.     };
  136.     int precision() { return aPrecision; };
  137.     int precision(int p)
  138.     {
  139.         int r = aPrecision;
  140.         aPrecision = p;
  141.         return r;
  142.     };
  143.     int rdstate() { return aState; };
  144.     int eof() { return aState & eofbit; };
  145.     int fail() { return aState & (failbit | badbit | hardfail); };
  146.     int bad() { return aState & (badbit | hardfail); };
  147.     int good() { return aState == 0; };
  148.     void clear(int i = 0) { aState = i; };
  149.     operator void *() { return fail() ? 0 : this; };
  150.     int operator !() { return fail(); };
  151.     streambuf* rdbuf() { return aBuf; };
  152.     static void sync_with_stdio() { };
  153.     static unsigned long bitalloc();
  154.     static int xalloc();
  155.     long &iword(int i) { return userword(i); };
  156.     void *&pword(int i) { return (void *&) userword(i); };
  157.  
  158.     static const unsigned long basefield;
  159.     static const unsigned long adjustfield;
  160.     static const unsigned long floatfield;
  161.  
  162. protected:
  163.     ios() { init(NULL); };
  164.     void init(streambuf *);
  165.  
  166.     streambuf *aBuf;
  167.     int aState;
  168.     ostream *aTie;
  169.     short int aPrecision;
  170.     char aFill;
  171.     short aWidth;
  172.     unsigned long aFlags;
  173.  
  174. private:
  175.     ios(const ios &);
  176.     ios &operator =(const ios &);
  177.  
  178.     static unsigned long aNextBit;
  179.     static int aNextWord;
  180.  
  181.     long *aUser;
  182.     int aNuser;
  183.     long &userword(int i);
  184. };
  185.  
  186. ios &dec(ios &);
  187. ios &hex(ios &);
  188. ios &oct(ios &);
  189.  
  190. class streambuf {
  191. protected:
  192.     streambuf();
  193.     streambuf(char *, int);
  194. public:          
  195.     virtual ~streambuf();
  196.     int in_avail() { return aGTop - aGPos; };
  197.     int out_waiting() { return aPPos - aPBase; };
  198.     int sbumpc()
  199.     {
  200.         return (in_avail() > 0 || underflow() != EOF) ? *((unsigned char *) (aGPos++)) : EOF;
  201.     };
  202.     int sgetc()
  203.     {
  204.         return in_avail() > 0 ? *((unsigned char *) aGPos) : underflow();
  205.     };
  206.     int sgetn(char *, int);
  207.     int snextc()
  208.     {
  209.         return sbumpc() == EOF ? EOF : sgetc();
  210.     };
  211.     void stossc() { sbumpc(); };
  212.     int sputbackc(char c)
  213.     {
  214.         return aGPos > aBase ? (*((unsigned char *) --aGPos) = c) : pbackfail(c);
  215.     };
  216.     int sputc(int c)
  217.     {
  218.         return aPPos < aTop ? (*((unsigned char *) aPPos++) = c) : overflow(c);
  219.     };
  220.     int sputn(const char *,int);
  221.     virtual int sync()
  222.     {
  223.         return (in_avail() != 0 || out_waiting() != 0) ? EOF : 0; 
  224.     };
  225.     virtual streampos seekoff(streamoff, ios::seek_dir, int = ios::in|ios::out)
  226.     {
  227.         return (streampos) EOF;
  228.     };
  229.     virtual streampos seekpos(streampos p, int mode = ios::in|ios::out)
  230.     {
  231.         return seekoff(streamoff(p),ios::beg,mode);
  232.     }
  233.     virtual streambuf *setbuf(char *, size_t);
  234. protected:
  235.     void setbuffer(char *, unsigned long n, int dynamic = 0);
  236.     int allocate()
  237.     {
  238.         return (aBase == NULL && !aUnbuffered) ? (doallocate() == EOF ? EOF : 1) : 0;
  239.     };
  240.     int unbuffered() { return aUnbuffered; };
  241.     void unbuffered(int i) { aUnbuffered = i; };
  242.     virtual int overflow(int = EOF);
  243.     virtual int underflow();
  244.     virtual int xsputn(const char *,int);
  245.     virtual int xsgetn(char *,int);
  246.     virtual int pbackfail(int) { return EOF; };
  247.     virtual int doallocate();
  248.     void pbump(int i) { aPPos += i; };
  249.     void gbump(int i) { aGPos += i; };
  250. protected:
  251.     char *aBase;
  252.     char *aTop;
  253.     char *aPBase;
  254.     char *aPPos;
  255.     char *aGPos;
  256.     char *aGTop;
  257.     short int aAlloc;
  258.     short int aUnbuffered;
  259. };
  260.  
  261. class istream : virtual public ios {
  262. public:
  263.     istream(streambuf *b) : ios(b) { };
  264.     virtual ~istream() { };
  265. public:
  266.     int ipfx(int need = 0);
  267.     void isfx() { };
  268.     istream &operator >>(unsigned char *s) { return (*this) >> (char *) s; };
  269.     istream &operator >>(signed char *s) { return (*this) >> (char *) s; };
  270.     istream &operator >>(char *);
  271.     istream &operator >>(char &);
  272.     istream &operator >>(unsigned char &c) { return (*this) >> (char &) c; };
  273.     istream &operator >>(signed char &c) { return (*this) >> (char &) c; };
  274.     istream &operator >>(short &);
  275.     istream &operator >>(unsigned short &);
  276.     istream &operator >>(int &);
  277.     istream &operator >>(unsigned int &);
  278.     istream &operator >>(long &);
  279.     istream &operator >>(unsigned long &);
  280.     istream &operator >>(float &);
  281.     istream &operator >>(double &);
  282.     istream &operator >>(long double &);
  283.     istream &operator >>(streambuf *);
  284.     istream &operator >>(istream &(*f)(istream &))
  285.     {
  286.         return (*f)(*this);
  287.     };
  288.     istream &operator >>(ios &(*f)(ios &))
  289.     {
  290.         (*f)(*this);
  291.         return *this;
  292.     };
  293.     istream &get(char *, int, char = '\n');
  294.     istream &get(unsigned char *s, int n, char delimiter = '\n')
  295.     {
  296.         return get((char *) s, n, delimiter);
  297.     };
  298.     istream &get(signed char *s, int n, char delimiter = '\n')
  299.     {
  300.         return get((char *) s, n, delimiter);
  301.     };
  302.     istream &getline(char *, int, char = '\n');
  303.     istream &getline(unsigned char *s, int n, char delimiter = '\n')
  304.     {
  305.         return getline((char *) s, n, delimiter);
  306.     };
  307.     istream &getline(signed char *s, int n, char delimiter = '\n')
  308.     {
  309.         return getline((char *) s, n, delimiter);
  310.     };
  311.     istream &get(streambuf &, char = '\n');
  312.     istream &get(signed char &c)
  313.     {
  314.         return get((char &) c);
  315.     };
  316.     istream &get(unsigned char &c)
  317.     {
  318.         return get((char &) c);
  319.     };
  320.     istream &get(char &);
  321.     int get();
  322.     istream &ignore(int = 1, int = EOF);
  323.     istream &read(unsigned char *s, int n)
  324.     {
  325.         return read((char *) s, n);
  326.     };
  327.     istream &read(signed char *s, int n)
  328.     {
  329.         return read((char *) s, n);
  330.     };
  331.     istream &read(char *, int);
  332.     int gcount() { return aLastCount; };
  333.     int peek();
  334.     istream &putback(char c)
  335.     {
  336.         if (good())
  337.             rdbuf()->sputbackc(c);
  338.         return *this;
  339.     };
  340.     int sync()
  341.     {
  342.         return rdbuf()->sync();
  343.     };
  344.     istream &seekg(streampos);
  345.     istream &seekg(streamoff, ios::seek_dir);
  346.     streampos tellg()
  347.     {
  348.         return rdbuf()->seekoff(0,ios::cur,ios::in);
  349.     };
  350. protected:
  351.     istream() : ios() { };
  352. private:
  353.     istream(const istream &);
  354.     istream &operator =(const istream &);
  355.     int aLastCount;
  356. };
  357.  
  358. istream &ws(istream &);
  359.  
  360. class ostream : virtual public ios {
  361. public:
  362.     ostream(streambuf *b) : ios(b) { };
  363.     virtual ~ostream() { };
  364. public:
  365.     int opfx();
  366.     void osfx();
  367.     ostream &operator <<(signed char c)
  368.     {
  369.         return (*this) << (char) c;
  370.     };
  371.     ostream &operator <<(unsigned char c)
  372.     {
  373.         return (*this) << (char) c;
  374.     };
  375.     ostream &operator <<(char);
  376.     ostream &operator <<(const unsigned char *s)
  377.     {
  378.         return (*this) << (const char *) s; 
  379.     };
  380.     ostream &operator <<(const signed char *s)
  381.     {
  382.         return (*this) << (const char *) s;
  383.     };
  384.     ostream &operator <<(const char *);
  385.     ostream &operator <<(short i)
  386.     {
  387.         return (*this) << (long) i;
  388.     };
  389.     ostream &operator <<(unsigned short i)
  390.     {
  391.         return (*this) << (unsigned long) i;
  392.     };
  393.     ostream &operator <<(int i)
  394.     {
  395.         return (*this) << (long) i;
  396.     };
  397.     ostream &operator <<(unsigned int i)
  398.     {
  399.         return (*this) << (unsigned long) i;
  400.     };
  401.     ostream &operator <<(long);
  402.     ostream &operator <<(unsigned long);
  403.     ostream &operator <<(float);
  404.     ostream &operator <<(double);
  405.     ostream &operator <<(void *);
  406.     ostream &operator <<(streambuf *);
  407.     ostream &operator <<(ostream &(*f)(ostream &))
  408.     {
  409.         return (*f)(*this);
  410.     };
  411.     ostream &operator <<(ios &(*f)(ios &))
  412.     {
  413.         (*f)(*this);
  414.         return *this;
  415.     };
  416.     ostream &put(char c)
  417.     {
  418.         if (opfx() != EOF)
  419.             rdbuf()->sputc(c);
  420.         return *this;
  421.     };
  422.     ostream &write(const signed char *s, int n)
  423.     {
  424.         return write((const char *) s,n);
  425.     };
  426.     ostream &write(const unsigned char *s, int n)
  427.     {
  428.         return write((const char *) s,n);
  429.     };
  430.     ostream &write(const char *s, int n)
  431.     {
  432.         if (opfx() != EOF)
  433.             rdbuf()->sputn(s,n);
  434.         return *this;
  435.     };
  436.     ostream &flush()
  437.     {
  438.         rdbuf()->sync();
  439.         return *this;
  440.     };
  441.     streampos tellp()
  442.     {
  443.         return rdbuf()->seekoff(0,ios::cur,ios::out);
  444.     };
  445.     ostream &seekp(streampos, ios::seek_dir = ios::beg);
  446.     ostream &seekp(streamoff, ios::seek_dir);
  447. protected:
  448.     ostream() : ios() { };
  449. private:
  450.     ostream(const ostream &);
  451.     ostream &operator =(const ostream &);
  452. };
  453.  
  454. ostream &flush(ostream &);
  455. ostream &endl(ostream &);
  456. ostream &ends(ostream &);
  457.  
  458. class iostream : private virtual ios, public ostream, public istream {
  459. public:
  460.     iostream(streambuf *b) : ios(b), istream(), ostream() { };
  461.     virtual ~iostream() { };
  462. protected:
  463.     iostream() : ios(), istream(), ostream() { }
  464. private:
  465.     iostream(const iostream &);
  466.     iostream &operator =(const iostream &);
  467. };
  468.  
  469. class istream_withassign : private virtual ios, public istream {
  470. public:
  471.     istream_withassign() : ios(0) { };
  472.     istream_withassign(streambuf *b) : ios(b) { };
  473.     istream_withassign(istream &i) : ios(i.rdbuf()) { };
  474.     virtual ~istream_withassign() { };
  475.     istream_withassign& operator =(streambuf *b) { init(b); return *this; };
  476.     istream_withassign& operator =(istream &i) { init(i.rdbuf()); return *this; };
  477. private:
  478.     istream_withassign(const istream_withassign &);
  479.     istream_withassign &operator =(const istream_withassign &);
  480. };
  481.  
  482. class ostream_withassign : private virtual ios, public ostream {
  483. public:
  484.     ostream_withassign() : ios(0) { };
  485.     ostream_withassign(streambuf *b) : ios(b) { };
  486.     ostream_withassign(ostream &o) : ios(o.rdbuf()) { };
  487.     virtual ~ostream_withassign() { };
  488.     ostream_withassign &operator =(streambuf *b) { init(b); return *this; };
  489.     ostream_withassign &operator =(ostream &o) { init(o.rdbuf()); return *this; };
  490. private:
  491.     ostream_withassign(const ostream_withassign &);
  492.     ostream_withassign &operator =(const ostream_withassign &);
  493. };
  494.  
  495. class iostream_withassign : private virtual ios, public iostream {
  496. public:
  497.     iostream_withassign() : ios(0) { };
  498.     iostream_withassign(streambuf *b) : ios(b) { };
  499.     iostream_withassign(ios &s) : ios(s.rdbuf()) { };
  500.     virtual ~iostream_withassign() { };
  501.     iostream_withassign &operator =(streambuf *b) { init(b); return *this; };
  502.     iostream_withassign &operator =(ios &s) { init(s.rdbuf()); return *this; };
  503. private:
  504.     iostream_withassign(const iostream_withassign &);
  505.     iostream_withassign &operator =(const iostream_withassign &);
  506. };
  507.  
  508. extern istream_withassign& cin;
  509. extern ostream_withassign& cout;
  510. extern ostream_withassign& cerr;
  511. extern ostream_withassign& clog;
  512.  
  513. #endif
  514.